SBC_AL.c

Go to the documentation of this file.

#include "derivative.h"
#include "compile_options.h"
#include "HAL.h"
#include "DSPI.h"
#include "MailScheduler.h"
#include "CG147.h"
#include "CG147_Diag.h"
#include "SBC_AL.h"
#include "Utils.h"
#include "MMA51xx.h"
#include "SIU.h"
/*
 ******************************************************************************
 * constants
 ******************************************************************************
 */
/******************************************************************************/
static const uint8_t cau8SBCSquibFiringStatusCmd[] =
{
  SBC_FIRE_COUNTER, SBC_FIRE_COUNTER, SBC_FIRE_COUNTER, SBC_FIRE_COUNTER,
  SBC_FIRE_COUNTER, SBC_FIRE_COUNTER, SBC_FIRE_COUNTER, SBC_FIRE_COUNTER,
  SBC_FIRE_COUNTER, SBC_FIRE_COUNTER, SBC_FIRE_COUNTER, SBC_FIRE_COUNTER,
  SBC_FIRE_COUNTER, SBC_CLEAR_FIRE_CNT };

static const uint8_t cau8SBCSquibFiringStatusArg[] =
{
  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x00,
  0x00 };

const uint16_t cu16PresentSquibs = (SQUIB_CH0_PRESENT | /* Driver frontal airbag */
    SQUIB_CH1_PRESENT | /* Driver seatbelt pre-tensioner */
    SQUIB_CH2_ABSENT | /* Nothing */
    SQUIB_CH3_PRESENT | /* Side-passenger frontal airbag */
    SQUIB_CH4_PRESENT | /* Side-passenger seat-belt pre-tensioner */
    SQUIB_CH5_ABSENT | /* Nothing */
    SQUIB_CH6_PRESENT | /* left side-curtain airbag */
    SQUIB_CH7_ABSENT | /* Nothing */
    SQUIB_CH8_ABSENT | /* Nothing */
    SQUIB_CH9_PRESENT | /* right side-curtain airbag */
    SQUIB_CH10_ABSENT | /* Nothing */
    SQUIB_CH11_ABSENT); /* Nothing */
const uint16_t cu16PresentSatellites = (SAT_CH0_SLOT0_PRESENT | /* Front-left accelerometer */
    SAT_CH0_SLOT1_ABSENT | /* Nothing */
    SAT_CH0_SLOT2_ABSENT | /* Nothing */
    SAT_CH1_SLOT0_PRESENT | /* Front-right accelerometer */
    SAT_CH1_SLOT1_ABSENT | /* Nothing */
    SAT_CH1_SLOT2_ABSENT | /* Nothing */
    SAT_CH2_SLOT0_PRESENT | /* left-side accelerometer */
    SAT_CH2_SLOT1_ABSENT | /* Nothing */
    SAT_CH2_SLOT2_ABSENT | /* Nothing */
    SAT_CH3_SLOT0_PRESENT | /* right-side accelerometer */
    SAT_CH3_SLOT1_ABSENT | /* Nothing */
    SAT_CH3_SLOT2_ABSENT /* Nothing */
);
const uint16_t cu16FiredSquibs = (SQUIB_CH0_NOT_FIRED | SQUIB_CH0_NOT_FIRED
    | SQUIB_CH1_NOT_FIRED | SQUIB_CH2_NOT_FIRED | SQUIB_CH3_NOT_FIRED
    | SQUIB_CH4_NOT_FIRED | SQUIB_CH5_NOT_FIRED | SQUIB_CH6_NOT_FIRED
    | SQUIB_CH7_NOT_FIRED | SQUIB_CH8_NOT_FIRED | SQUIB_CH9_NOT_FIRED
    | SQUIB_CH10_NOT_FIRED | SQUIB_CH11_NOT_FIRED);
const uint16_t cu16CrashedSatellites = (SAT_CH0_SLOT0_NOT_CRASHED
    | SAT_CH0_SLOT1_NOT_CRASHED | SAT_CH0_SLOT2_NOT_CRASHED
    | SAT_CH1_SLOT0_NOT_CRASHED | SAT_CH1_SLOT1_NOT_CRASHED
    | SAT_CH1_SLOT2_NOT_CRASHED | SAT_CH2_SLOT0_NOT_CRASHED
    | SAT_CH2_SLOT1_NOT_CRASHED | SAT_CH2_SLOT2_NOT_CRASHED
    | SAT_CH3_SLOT0_NOT_CRASHED | SAT_CH3_SLOT1_NOT_CRASHED
    | SAT_CH3_SLOT2_NOT_CRASHED);
const uint8_t cu8SBCSatelliteData[] =
{
  /* Satellite 1 */
  /* PROTOCOL */0x04u,
  /* N_DATA_BLOCKS */0x20u,
  /* MANUFACTURER */0x46u,
  /* SENSOR_TYPE */0x01u,
  /* AXIS */0x00u,
  /* RANGE */0x09u,
  /* DEVCFG2 */0x00u,
  /* PRODUCT_REVISION */0x11u,
  /* DEVCFG6 */0x00u,
  /* PROD_DATE_1 */0x00u,
  /* PROD_DATE_2*/0x00u,
  /* SN0 */0x00u,
  /* SN1 */0x00u,
  /* SN2 */0x00u,
  /* SN3 */0x00u,
  /* INIT_RAW_OFFSET */0x00u,
  /* COMBINED_OFFSET_SELF_TEST */0x00u,
  /* AVG_SELF_TEST */0x00u,
  /* DEVCFG1 */0x00,
  /* Satellite 2 */
  /* PROTOCOL */0x04u,
  /* N_DATA_BLOCKS */0x20u,
  /* MANUFACTURER */0x46u,
  /* SENSOR_TYPE */0x01u,
  /* AXIS */0x00u,
  /* RANGE */0x09u,
  /* DEVCFG2 */0x00u,
  /* PRODUCT_REVISION */0x11u,
  /* DEVCFG6 */0x00u,
  /* PROD_DATE_1 */0x00u,
  /* PROD_DATE_2*/0x00u,
  /* SN0 */0x00u,
  /* SN1 */0x00u,
  /* SN2 */0x00u,
  /* SN3 */0x00u,
  /* INIT_RAW_OFFSET */0x00u,
  /* COMBINED_OFFSET_SELF_TEST */0x00u,
  /* AVG_SELF_TEST */0x00u,
  /* DEVCFG1 */0x00,
  /* Satellite 3 */
  /* PROTOCOL */0x04u,
  /* N_DATA_BLOCKS */0x20u,
  /* MANUFACTURER */0x46u,
  /* SENSOR_TYPE */0x01u,
  /* AXIS */0x00u,
  /* RANGE */0x09u,
  /* DEVCFG2 */0x00u,
  /* PRODUCT_REVISION */0x11u,
  /* DEVCFG6 */0x00u,
  /* PROD_DATE_1 */0x00u,
  /* PROD_DATE_2*/0x00u,
  /* SN0 */0x00u,
  /* SN1 */0x00u,
  /* SN2 */0x00u,
  /* SN3 */0x00u,
  /* INIT_RAW_OFFSET */0x00u,
  /* COMBINED_OFFSET_SELF_TEST */0x00u,
  /* AVG_SELF_TEST */0x00u,
  /* DEVCFG1 */0x00,
  /* Satellite 4 */
  /* PROTOCOL */0x04u,
  /* N_DATA_BLOCKS */0x20u,
  /* MANUFACTURER */0x46u,
  /* SENSOR_TYPE */0x01u,
  /* AXIS */0x00u,
  /* RANGE */0x09u,
  /* DEVCFG2 */0x00u,
  /* PRODUCT_REVISION */0x11u,
  /* DEVCFG6 */0x00u,
  /* PROD_DATE_1 */0x00u,
  /* PROD_DATE_2*/0x00u,
  /* SN0 */0x00u,
  /* SN1 */0x00u,
  /* SN2 */0x00u,
  /* SN3 */0x00u,
  /* INIT_RAW_OFFSET */0x00u,
  /* COMBINED_OFFSET_SELF_TEST */0x00u,
  /* AVG_SELF_TEST */0x00u,
  /* DEVCFG1 */0x00,
  /* Satellite 5 */
  /* PROTOCOL */0x04u,
  /* N_DATA_BLOCKS */0x20u,
  /* MANUFACTURER */0x46u,
  /* SENSOR_TYPE */0x01u,
  /* AXIS */0x00u,
  /* RANGE */0x09u,
  /* DEVCFG2 */0x00u,
  /* PRODUCT_REVISION */0x11u,
  /* DEVCFG6 */0x00u,
  /* PROD_DATE_1 */0x00u,
  /* PROD_DATE_2*/0x00u,
  /* SN0 */0x00u,
  /* SN1 */0x00u,
  /* SN2 */0x00u,
  /* SN3 */0x00u,
  /* INIT_RAW_OFFSET */0x00u,
  /* COMBINED_OFFSET_SELF_TEST */0x00u,
  /* AVG_SELF_TEST */0x00u,
  /* DEVCFG1 */0x00,
  /* Satellite 6 */
  /* PROTOCOL */0x04u,
  /* N_DATA_BLOCKS */0x20u,
  /* MANUFACTURER */0x46u,
  /* SENSOR_TYPE */0x01u,
  /* AXIS */0x00u,
  /* RANGE */0x09u,
  /* DEVCFG2 */0x00u,
  /* PRODUCT_REVISION */0x11u,
  /* DEVCFG6 */0x00u,
  /* PROD_DATE_1 */0x00u,
  /* PROD_DATE_2*/0x00u,
  /* SN0 */0x00u,
  /* SN1 */0x00u,
  /* SN2 */0x00u,
  /* SN3 */0x00u,
  /* INIT_RAW_OFFSET */0x00u,
  /* COMBINED_OFFSET_SELF_TEST */0x00u,
  /* AVG_SELF_TEST */0x00u,
  /* DEVCFG1 */0x00,
  /* Satellite 7 */
  /* PROTOCOL */0x04u,
  /* N_DATA_BLOCKS */0x20u,
  /* MANUFACTURER */0x46u,
  /* SENSOR_TYPE */0x01u,
  /* AXIS */0x00u,
  /* RANGE */0x09u,
  /* DEVCFG2 */0x00u,
  /* PRODUCT_REVISION */0x11u,
  /* DEVCFG6 */0x00u,
  /* PROD_DATE_1 */0x00u,
  /* PROD_DATE_2*/0x00u,
  /* SN0 */0x00u,
  /* SN1 */0x00u,
  /* SN2 */0x00u,
  /* SN3 */0x00u,
  /* INIT_RAW_OFFSET */0x00u,
  /* COMBINED_OFFSET_SELF_TEST */0x00u,
  /* AVG_SELF_TEST */0x00u,
  /* DEVCFG1 */0x00,
  /* Satellite 8 */
  /* PROTOCOL */0x04u,
  /* N_DATA_BLOCKS */0x20u,
  /* MANUFACTURER */0x46u,
  /* SENSOR_TYPE */0x01u,
  /* AXIS */0x00u,
  /* RANGE */0x09u,
  /* DEVCFG2 */0x00u,
  /* PRODUCT_REVISION */0x11u,
  /* DEVCFG6 */0x00u,
  /* PROD_DATE_1 */0x00u,
  /* PROD_DATE_2*/0x00u,
  /* SN0 */0x00u,
  /* SN1 */0x00u,
  /* SN2 */0x00u,
  /* SN3 */0x00u,
  /* INIT_RAW_OFFSET */0x00u,
  /* COMBINED_OFFSET_SELF_TEST */0x00u,
  /* AVG_SELF_TEST */0x00u,
  /* DEVCFG1 */0x00,
  /* Satellite 9 */
  /* PROTOCOL */0x04u,
  /* N_DATA_BLOCKS */0x20u,
  /* MANUFACTURER */0x46u,
  /* SENSOR_TYPE */0x01u,
  /* AXIS */0x00u,
  /* RANGE */0x09u,
  /* DEVCFG2 */0x00u,
  /* PRODUCT_REVISION */0x11u,
  /* DEVCFG6 */0x00u,
  /* PROD_DATE_1 */0x00u,
  /* PROD_DATE_2*/0x00u,
  /* SN0 */0x00u,
  /* SN1 */0x00u,
  /* SN2 */0x00u,
  /* SN3 */0x00u,
  /* INIT_RAW_OFFSET */0x00u,
  /* COMBINED_OFFSET_SELF_TEST */0x00u,
  /* AVG_SELF_TEST */0x00u,
  /* DEVCFG1 */0x00,
  /* Satellite 10 */
  /* PROTOCOL */0x04u,
  /* N_DATA_BLOCKS */0x20u,
  /* MANUFACTURER */0x46u,
  /* SENSOR_TYPE */0x01u,
  /* AXIS */0x00u,
  /* RANGE */0x09u,
  /* DEVCFG2 */0x00u,
  /* PRODUCT_REVISION */0x11u,
  /* DEVCFG6 */0x00u,
  /* PROD_DATE_1 */0x00u,
  /* PROD_DATE_2*/0x00u,
  /* SN0 */0x00u,
  /* SN1 */0x00u,
  /* SN2 */0x00u,
  /* SN3 */0x00u,
  /* INIT_RAW_OFFSET */0x00u,
  /* COMBINED_OFFSET_SELF_TEST */0x00u,
  /* AVG_SELF_TEST */0x00u,
  /* DEVCFG1 */0x00,
  /* Satellite 11 */
  /* PROTOCOL */0x04u,
  /* N_DATA_BLOCKS */0x20u,
  /* MANUFACTURER */0x46u,
  /* SENSOR_TYPE */0x01u,
  /* AXIS */0x00u,
  /* RANGE */0x09u,
  /* DEVCFG2 */0x00u,
  /* PRODUCT_REVISION */0x11u,
  /* DEVCFG6 */0x00u,
  /* PROD_DATE_1 */0x00u,
  /* PROD_DATE_2*/0x00u,
  /* SN0 */0x00u,
  /* SN1 */0x00u,
  /* SN2 */0x00u,
  /* SN3 */0x00u,
  /* INIT_RAW_OFFSET */0x00u,
  /* COMBINED_OFFSET_SELF_TEST */0x00u,
  /* AVG_SELF_TEST */0x00u,
  /* DEVCFG1 */0x00,
  /* Satellite 12 */
  /* PROTOCOL */0x04u,
  /* N_DATA_BLOCKS */0x20u,
  /* MANUFACTURER */0x46u,
  /* SENSOR_TYPE */0x01u,
  /* AXIS */0x00u,
  /* RANGE */0x09u,
  /* DEVCFG2 */0x00u,
  /* PRODUCT_REVISION */0x11u,
  /* DEVCFG6 */0x00u,
  /* PROD_DATE_1 */0x00u,
  /* PROD_DATE_2*/0x00u,
  /* SN0 */0x00u,
  /* SN1 */0x00u,
  /* SN2 */0x00u,
  /* SN3 */0x00u,
  /* INIT_RAW_OFFSET */0x00u,
  /* COMBINED_OFFSET_SELF_TEST */0x00u,
  /* AVG_SELF_TEST */0x00u,
  /* DEVCFG1 */0x00 };
const uint8_t cau8SBCSatTestVariableFilter[] =
{
  /* PROTOCOL */TRUE,
  /* N_DATA_BLOCKS */TRUE,
  /* MANUFACTURER */CLEAR,
  /* SENSOR_TYPE */TRUE,
  /* AXIS */CLEAR,
  /* RANGE */CLEAR,
  /* DEVCFG2 */CLEAR,
  /* PRODUCT_REVISION */CLEAR,
  /* DEVCFG6 */CLEAR,
  /* PROD_DATE_1 */CLEAR,
  /* PROD_DATE_2*/CLEAR,
  /* SN0 */CLEAR,
  /* SN1 */CLEAR,
  /* SN2 */CLEAR,
  /* SN3 */CLEAR,
  /* INIT_RAW_OFFSET */CLEAR,
  /* COMBINED_OFFSET_SELF_TEST */CLEAR,
  /* AVG_SELF_TEST */CLEAR,
  /* DEVCFG1 */CLEAR, };
/*
 ******************************************************************************
 * Globals
 ******************************************************************************
 */
static uint32_t gu32SBCIgnoredResponse;
uint16_t gu16ActivePSI5Channels;
uint16_t gu16ActiveSquibChannels;
uint16_t gu16FiredSquibs;
uint16_t gu16SquibsToFire;
uint16_t gu16CrashedSatellites;
uint16_t gu16ConfirmedSatellites;
uint32_t gu32SBCTime;
uint8_t gu8SBCSatelliteData[SBC_N_SATELLITES_POSSIBLE * MMA5100_N_REGISTERS];
/*
 ******************************************************************************
 * vfnSBCEnableWarningLamp
 * Functional only without any scheduler and 16-bit format
 ******************************************************************************
 */
uint8_t u8fnSBCPreSchedulerEnableWarningLamp(uint8_t u8Enable)
{
  /* Turn lamp warning lamp on or off according to passed arg */
  return (u8fnCG147Transcieve(SBC_SET_I_AIO, u8Enable, CG147_SPI_CONFIG));
}
/*
 ******************************************************************************
 * vfnSBCEnableWarningLamp
 * Functional with Scheduled SPI Tx in 17-bit configuration ONLY
 ******************************************************************************
 */
uint8_t u8fnSBCEnableWarningLamp(uint8_t u8Enable)
{
  /* Turn lamp warning lamp on or off according to passed arg */
  return (u8fnCG147ScheduleSafeTransfer(CG147_SPI_CONFIG_EXT, 
                                        SBC_SET_I_AIO, u8Enable,
                                        (uint16_t*)&gu32SBCIgnoredResponse,
                                        (uint32_t*)&gu32SBCTime));
}
/*
 ******************************************************************************
 * vfnSBCPreSchedulerInit
 * Functional without a scheduler running only.
 ******************************************************************************
 */
void vfnSBCPreSchedulerInit(void)
{
  vfnCG147Init(CG147_SPI_CONFIG, DSPI0C6, DSPI0C7, PIN_N_SYS_RES);
  /* Keep the lamp on */
  (void)u8fnSBCPreSchedulerEnableWarningLamp(TRUE);
  
  return;
}
/*
 ******************************************************************************
 * u8fnSBCInit
 * Requires scheduler to be working, switches between 16- to 17-bit config.
 ******************************************************************************
 */
uint32_t u32fnSBCInit(void)
{
  uint32_t u32Status;
  uint16_t u16LocalStatus;
  uint32_t u32LocalStatus;
  uint32_t au32LocalSchedResults[SBC_N_CONFIG_BUFFER_SIZE];
  
  /* Init variables */
  u16LocalStatus = CLEAR;
  u32Status = CLEAR;
  u32LocalStatus = CLEAR;
  
  /* We should load the active PSI5 satellites from NV memory */
  gu16ActivePSI5Channels = cu16PresentSatellites;
  
  /* Also load the active Squib channels */
  gu16ActiveSquibChannels = cu16PresentSquibs;
  
  /* Do the same for fired squibs */
  gu16FiredSquibs = cu16FiredSquibs;
  
  /* And for crashed satellites */
  gu16CrashedSatellites = cu16CrashedSatellites;
  
  if(SBC_N_CONFIG_BUFFER_SIZE >= cu8CG147InitCmdsArgsSize)
  {
    /* Transfer all this data in 16-bit mode to the device, followed by a */
    /* switch to 17-bit mode. */
    if(CLEAR == u8fnCG147ScheduleBatchTransfer(CG147_SPI_CONFIG,
                                               (uint8_t*)&cau8CG147InitCmdsIn16Bit,
                                               (uint8_t*)&cau8CG147InitArgsIn16Bit,
                                               (uint16_t*)&au32LocalSchedResults,
                                               cu8CG147InitCmdsArgsSize,
                                               (uint32_t*)&gu32SBCTime))
    { 
      /* ******** EVERYTHING AFTER HERE MUST BE IN 17-BIT FORMAT  ****************/
      /* Now launch Watch-dog timers with default seeds */
      u16LocalStatus = u8fnCG147ScheduleSafeTransfer(CG147_SPI_CONFIG_EXT,
                                                     SBC_WD2_TRIGGER,
                                                     SBC_WD_RESPONSE_8,
                                                     (uint16_t*)&gu32CG147WatchDog2RequestToMCU,
                                                     (uint32_t*)&gu32SBCTime);
      u16LocalStatus |= u8fnCG147ScheduleSafeTransfer(CG147_SPI_CONFIG_EXT,
                                                      SBC_WD3_TRIGGER,
                                                      SBC_WD_RESPONSE_8,
                                                      (uint16_t*)&gu32CG147WatchDog3RequestToMCU,
                                                      (uint32_t*)&gu32SBCTime);
      /* Let's continue if life has been good */
      if(CLEAR == u16LocalStatus)
      {
        /* Here we wait for the scheduler to send the above SPI frames */
        while(1u > u32fnSchedIsTxDone(gu32SBCTime))
        {
          /* Wait here */
        };

        /* We will now gather initial data for our satellites */
        if(MMA5100_SENSOR_READY_STATUS & 
            u16fnSBCGatherPSI5SatelliteData((uint8_t*)&gu8SBCSatelliteData))
        {
          u16LocalStatus = 
            u16fnSBCTestPSI5SatelliteData((uint8_t*)&gu8SBCSatelliteData,
                                          (uint8_t*)&cu8SBCSatelliteData,
                                          (uint8_t*)&cau8SBCSatTestVariableFilter,
                                          (uint16_t*)&cu16PresentSatellites);
          /* Figure out which are our usable squibs based on this */
          gu16ActivePSI5Channels = ((uint16_t)~u16LocalStatus &
                                    cu16PresentSatellites);

          /* If the activity above is not transparent, we need to flag it */
          if(gu16ActivePSI5Channels == cu16PresentSatellites)
          {
            /* Nothing */
          } /* end if - Present satellites match active satellites */
          else 
          {
            /* Flag in status */
            u32Status = (uint32_t)u16LocalStatus;
          } /* End else - present satellites do not match active ones */
          
          /* Run initial tests for the SBC */
          u32LocalStatus = u32fnSBCPerformInitialTests();
          /* Act according to the status of the performed tests which are defined */
          /* within the CG147_Diag.h file.                                        */
          u32Status |= (u32LocalStatus << BITS_IN_16);
          if(CLEAR == (u32LocalStatus & SBC_DIAG_CRITICAL_FAILURE))
          {
#ifdef USE_AUTO_SYNC
            /* Switch over to CG147-driven Sync-pulses */
            u16LocalStatus = u8fnCG147ScheduleSafeTransfer(CG147_SPI_CONFIG_EXT,
                                                           SBC_PROG_PSYNC_MODE, 
                                                           (uint8_t)0xC5u,
                                                           (uint16_t*)&gu32SBCIgnoredResponse,
                                                           (uint32_t*)&gu32SBCTime);
#else
            (void)u8fnSBCSchedulePSync();
            u16LocalStatus = CLEAR;
            
#endif
            /* Stop warning lamp and link it to DIS_ALP status */
            u16LocalStatus |= u8fnCG147ScheduleSafeTransfer(CG147_SPI_CONFIG_EXT,
                                                            SBC_SET_I_AIO, 
                                                            (uint8_t)CLEAR,
                                                            (uint16_t*)&gu32SBCIgnoredResponse,
                                                            (uint32_t*)&gu32SBCTime);
            u16LocalStatus |= u8fnCG147ScheduleSafeTransfer(CG147_SPI_CONFIG_EXT,
                                                            SBC_PROG_AIO_WL, 
                                                            (uint8_t)0x03u,
                                                            (uint16_t*)&gu32SBCIgnoredResponse,
                                                            (uint32_t*)&gu32SBCTime);
            /* Only continue if we're good to go */
            /* We have finished all configuration. Schedule EOP */
            /* Schedule EOP after config */
            u16LocalStatus |= u8fnCG147ScheduleSafeTransfer(CG147_SPI_CONFIG_EXT, 
                                                            SBC_EOP, 
                                                            (uint8_t)0x03u,
                                                            (uint16_t*)&gu32SBCIgnoredResponse,
                                                            (uint32_t*)&gu32SBCTime);
            /* We're about to leave */
            if(CLEAR == u16LocalStatus)
            {
              /* Done */
              DELAY_MSEC(1u);
            }
            else
            {
              /* We're bruised */
              u32Status |= SBC_TEST_SCHEDULER_FAILED;
            }
          } /* End if - initial SBC tests were passed */
          else
          {
            u32Status |= SBC_TEST_SBC_FAILED;
          }
        } /* End if - satellites responded "ready" */
        else
        {
          /* Satellites did not initialize correctly */
          u32Status = SBC_TEST_ALL_SAT;
        } /* End else - satellites did not respond as "ready" */
      } /* End if - Scheduled WD data correctly. */
      else
      {
        /* Problem scheduling data. Exit with error code */
        u32Status = SBC_TEST_SCHEDULER_FAILED;
      } /* End else - WD scheduled incorrectly */
    } /* End if - 16-bit operations occurred successfully */ 
    else
    {
      u32Status = SBC_TEST_UNEXPECTED_SPI_RESULT;
    } /* End else: 16-bit operations did not occur successfully */
  } /* End if - IntCmds and args is correct */
  else
  {
    /* Programming error - go fix it */
    u32Status = 0xFFFFFFFF;
  } /* End else - IntCmds and Args is not correct */  
  return (u32Status);
}
/*
 ******************************************************************************
 * u32fnSBCPerformInitialTests
 * Functional with Scheduled SPI Tx in 17-bit configuration ONLY
 ******************************************************************************
 */
uint32_t u32fnSBCPerformInitialTests(void)
{
  /* General Status */
  uint32_t u32Status;
  uint8_t u8Counter;
  uint8_t u8TestCounter;
  

  u32Status = CLEAR;
  
  /* Perform POM tests */
  for(u8Counter = CLEAR; u8Counter < CG147_N_ER_LINES; u8Counter++)
  {
    for(u8TestCounter = CLEAR; u8TestCounter < cu8SizeOfSBCTests;
        u8TestCounter++)
    {
      u32Status |= u32fnSBCPerformInitialTestsPOM(u8Counter, u8TestCounter);
    }
  }
  /* At this point, we know whether the SBC is reliable or not as a unit */
  if(CLEAR == u32Status)
  {
    /* Next perform ADC, Mux tests */
    for(u8Counter = CLEAR; u8Counter < cu8SizeOfTestAnaHeadSettings; 
        u8Counter++)
    {
      u32Status |= u32fnSBCTestMuxAndADC(u8Counter);
    }
    
    if(((CG147_END_OF_PROGRAMMING_FLAG >> BITS_IN_BYTE) == u32Status) || 
       (CLEAR == u32Status)) 
    {
      /* Continue with FLM tests which will tell us if our squibs are ok */
      u32Status = u32fnSBCPerformInitialTestsFLM(gu16ActiveSquibChannels);
    }
    else
    {
      u32Status = SBC_TEST_SBC_FAILED;
    }
  }
  else
  {
    u32Status = SBC_TEST_SBC_FAILED;
  }
  return (u32Status);
}
/*
 ******************************************************************************
 * u16fnSBCGatherPSI5SatelliteData
 * Functional with Scheduled SPI Tx in 17-bit configuration ONLY
 ******************************************************************************
 */
uint16_t u16fnSBCGatherPSI5SatelliteData(uint8_t* pu8PSI5Data)
{
  /* Local variables */
  /* for loop counters */
  uint16_t u16Counter1;
  uint16_t u16Counter2;
  /* Temporary array for 16-bit data */
  uint16_t au16SBCSensorSettings[SBC_N_SATELLITES_POSSIBLE
  * SBC_SENSOR_DATA_ARRAY_SIZE];
  /* Index memory per data-nibble received */
  uint8_t au8SatIndex[SBC_N_SATELLITES_POSSIBLE];
  uint8_t au8SatIndexAdder[SBC_N_SATELLITES_POSSIBLE];
  uint32_t au32SatAlreadyWrittenMem[SBC_N_SATELLITES_POSSIBLE];
  /* Array to receive acceleration data */
  uint32_t au32TempRawDataDepot[5u];
  /* Mask used in inner for loop */
  uint16_t u16Mask;
  /* Status register */
  uint16_t u16Status;

  /* Init locals */
  u16Mask = CG147_SAT_MASK_MIN;
  u16Status = CLEAR;
  for(u16Counter1 = CLEAR; u16Counter1 < N_ELEMENTS(au32TempRawDataDepot); u16Counter1++)
  {
    au32TempRawDataDepot[u16Counter1] = CLEAR;
  }
  for(u16Counter1 = CLEAR; u16Counter1 < N_ELEMENTS(au16SBCSensorSettings); u16Counter1++)
  {
    au16SBCSensorSettings[u16Counter1] = CLEAR;
  }
  for(u16Counter1 = CLEAR; u16Counter1 < SBC_N_SATELLITES_POSSIBLE; u16Counter1++)
  {
    au8SatIndex[u16Counter1] = CLEAR;
    au8SatIndexAdder[u16Counter1] = CLEAR;
    au32SatAlreadyWrittenMem[u16Counter1] = CLEAR;
  }

  /* Wait for satellites to wake-up */
  DELAY_MSEC(195u);

  /* We will now gather and treat all data */
  for(u16Counter1 = CLEAR; u16Counter1 < N_ELEMENTS(au16SBCSensorSettings);
      u16Counter1 += SBC_N_SATELLITES_POSSIBLE)
  {
    /* Generate PSI5 sync pulse */
    vfnCG147SyncPulse(PIN_N_SYNC);
    SCHED_WHAT_IS_THE_TIME(gu32SBCTime);
    while (SCHED_500US_PERIOD > u32fnSchedHasTimeElapsed(gu32SBCTime))
    {
      /* Wait for two clicks to pass */
    }

    /* First, we need to gather data from satellites */
    (void)u32fnSBCSchedulePSISat((uint16_t*)&au32TempRawDataDepot);

    /* Reset mask for operations coming up */
    u16Mask = CG147_SAT_MASK_MIN;

    while (1u > u32fnSchedIsTxDone(gu32SBCTime))
    {
      /* Wait for one click to pass */

    }

    /* We have started getting data. Decode whatever we got in 32-bit to 16-bit format. */
    (void)u16fnCG147ExtractScheduledPSI5Accel((uint32_t*)&au32TempRawDataDepot,
    (uint16_t*)&(au16SBCSensorSettings[u16Counter1]),
    gu16ActivePSI5Channels);

    /* Next, we will figure out what this data means */
    for(u16Counter2 = CLEAR; u16Counter2 < SBC_N_SATELLITES_POSSIBLE; u16Counter2++)
    {
      /* Only if the satellite channel is active */
      if(gu16ActivePSI5Channels & u16Mask)
      {
        u16Status |= u16fnMMA5100TreatData((uint16_t*)&(au16SBCSensorSettings[u16Counter1 + u16Counter2]),
                                           (uint8_t*)&(pu8PSI5Data[(u16Counter2 * MMA5100_N_REGISTERS)]),
                                           (uint8_t*)&(au8SatIndex[u16Counter2]),
                                           (uint8_t*)&(au8SatIndexAdder[u16Counter2]),
                                           (uint32_t*)&(au32SatAlreadyWrittenMem[u16Counter2]));
      }
      else
      {
        /* Inactive sensor channel */
      }
      u16Mask <<= BIT0;
    }
    
  }
  return(u16Status);
}
/*
 ******************************************************************************
 * u16fnSBCTestPSI5SatelliteData
 * Functional with Scheduled SPI Tx in 17-bit configuration ONLY
 ******************************************************************************
 */
static uint16_t u16fnSBCTestPSI5SatelliteData(const uint8_t* au8SBCSatData,
                                              const uint8_t* au8SBCSatBasis,
                                              const uint8_t* au8SBCSatTestFilt,
                                              const uint16_t* pu16ActiveSat)
{
  uint16_t u16Status;
  uint16_t u16Mask;
  uint8_t u8Counter1;
  uint8_t u8Counter2;
  uint16_t u16LocalIndex;

  u16Status = CLEAR;

  u16Mask = CG147_SAT_MASK_MIN;

  for(u8Counter1 = CLEAR; u8Counter1 < SBC_N_SATELLITES_POSSIBLE; u8Counter1++)
  {
    if(u16Mask & *pu16ActiveSat)
    {
      for(u8Counter2 = CLEAR; u8Counter2 < MMA5100_N_REGISTERS; u8Counter2++)
      {
        if(TRUE == au8SBCSatTestFilt[u8Counter2])
        {
          u16LocalIndex = ((uint16_t)(MMA5100_N_REGISTERS * u8Counter1) +
          (uint16_t)u8Counter2);
          if(au8SBCSatData[u16LocalIndex] == au8SBCSatBasis[u16LocalIndex])
          {
            /* This is good - we passed the test */
          }
          else
          {
            /* This is bad - we failed the test and must report it */
            u16Status |= (BIT0 << u8Counter1);
          }
        }
        else
        {
          /* No test to perform */
        }
      }
    }
    else
    {
      /* Skip */
    }
    u16Mask <<= BIT0;
  }

  return (u16Status);
}
/*
 ******************************************************************************
 * u32fnSBCSchedulePSISat
 * Functional with Scheduled SPI Tx in 17-bit configuration ONLY
 ******************************************************************************
 */
uint32_t u32fnSBCSchedulePSISat(uint16_t* pu16RawAccelArray)
{
  uint32_t u32Status;

  u32Status = u8fnCG147ScheduleSafePSI5Accel(CG147_SPI_CONFIG_EXT_MONITORING,
                                              gu16ActivePSI5Channels,
                                              (uint32_t*)pu16RawAccelArray,
                                              (uint32_t*)&gu32SBCTime);
  
  if(u32Status != CLEAR)
  {
    u32Status = STATUS_SCHEDULER_PROBLEM;
  }
  else
  {
    /* Nothing to do */
  }
  return (u32Status);
}
/*
 ******************************************************************************
 * u8fnSBCSchedulePSync
 * Functional with Scheduled SPI Tx in 17-bit configuration ONLY
 ******************************************************************************
 */
uint8_t u8fnSBCSchedulePSync(void)
{
  return(u8fnCG147ScheduleSafeTransfer(CG147_SPI_CONFIG_EXT,
                                       SBC_PSI_SYNC_GEN, 
                                       CLEAR,
                                       (uint16_t*)&gu32SBCIgnoredResponse,
                                       (uint32_t*)&gu32SBCTime));
}
/*
 ******************************************************************************
 * u8fnSBCSyncSM
 * Functional with Scheduler
 ******************************************************************************
 */
uint8_t u8fnSBCSyncSM(const uint8_t cu8Period)
{
  uint8_t u8Status;
  
  u8Status = CLEAR;
  
  while(cu8Period != gu16CG147WatchDog2IsrCount)
  {
    /* Wait */
  }
  
  return(u8Status);
}
/*
 ******************************************************************************
 * u32fnSBCExtractPSISat
 * Functional with Scheduled SPI Tx in 17-bit configuration ONLY
 ******************************************************************************
 */
uint32_t u32fnSBCExtractPSISat(uint16_t* pu16RawAccelArray,
                               uint16_t* pu16Filtered)
{
  uint32_t u32Status;
  uint8_t u8Index;

  u32Status = u16fnCG147ExtractScheduledPSI5Accel((uint32_t*)pu16RawAccelArray,
  pu16Filtered,
  gu16ActivePSI5Channels);
  /* Filter signed data to unsigned centered at 512 cts */
  for(u8Index = CLEAR; u8Index < SBC_N_SATELLITES_POSSIBLE; u8Index++)
  {
    if((*pu16Filtered >= MMA5100_UL_FOR_DATA)
    || (*pu16Filtered <= MMA5100_LL_FOR_STATUS))
    {
      /* We are happy */
      *pu16Filtered = u16fn10BitOffsetFilter(*pu16Filtered);
    }
    else
    {
      u32Status |= ((gu16ActivePSI5Channels) & (BIT0 << u8Index));
      *pu16Filtered = 0x021Fu;
    }

    pu16Filtered++;
  }

  return (u32Status);
}
/*
 ******************************************************************************
 * u32fnSBCScheduleCmd
 * Functional with Scheduled SPI Tx in 17-bit configuration ONLY
 ******************************************************************************
 */
uint32_t u32fnSBCScheduleCmd(uint8_t u8Cmd, uint8_t u8Arg,
                             uint16_t* pu16Response)
{
  uint32_t u32Status;
  u32Status = u8fnCG147ScheduleSafeTransfer( CG147_SPI_CONFIG_EXT, u8Cmd, u8Arg,
                                             pu16Response,
                                             (uint32_t*)&gu32SBCTime);
  if(CLEAR == u32Status)
  {
    /* leave */
  }
  else
  {
    /* Flag it as a problem */
    u32Status = STATUS_SCHEDULER_PROBLEM;
  }

  return (u32Status);
}
/*
 ******************************************************************************
 * u32fnSBCFireSquibs
 * Functional with Scheduled SPI Tx in 17-bit configuration ONLY
 ******************************************************************************
 */
uint32_t u32fnSBCFireSquibs(const uint16_t cu16SquibMask)
{
  uint32_t u32Status;

  /* There's no case in executing this fn if the mask is empty */
  if(CLEAR != cu16SquibMask)
  {
    u32Status = u8fnCG147ScheduleSafeSquibFireStart(CG147_SPI_CONFIG_EXT,
                                                    cu16SquibMask,
                                                    (uint32_t*)&gu32SBCTime);
    if(CLEAR != u32Status)
    {
      u32Status = STATUS_SCHEDULER_PROBLEM;
    }
    else
    {
      /* Continue */

      /* Wait for Squibs to fire */
      DELAY_MSEC(2u);

      /* Stop firing squibs */
      u32Status = u8fnCG147ScheduleSafeSquibFireStop(CG147_SPI_CONFIG_EXT,
                                                     (uint32_t*)&gu32SBCTime);
      if(CLEAR != u32Status)
      {
        u32Status = STATUS_SCHEDULER_PROBLEM;
      }
      else
      {
        /* Nothing */
      }
    }
  }
  else
  {
    /* Get out */
    u32Status = CLEAR;
  }

  return (u32Status);
}
/*
 ******************************************************************************
 * u32fnSBCSquibFiringStatus
 * Functional with Scheduled SPI Tx in 17-bit configuration ONLY
 ******************************************************************************
 */
uint32_t u32fnSBCSquibFiringStatus(uint16_t* pu16Response)
{
  uint32_t u32Status;
  uint8_t u8LocalStatus;
  uint8_t u8Index;
  uint32_t au32LocalResults[N_ELEMENTS(cau8SBCSquibFiringStatusCmd)];
  uint8_t au8LocalResults[N_ELEMENTS(cau8SBCSquibFiringStatusCmd)];

  u32Status = u8fnCG147ScheduleSafeBatchTransfer(CG147_SPI_CONFIG_EXT,
                                                 (uint8_t*)cau8SBCSquibFiringStatusCmd,
                                                 (uint8_t*)cau8SBCSquibFiringStatusArg,
                                                 (uint16_t*)au32LocalResults,
                                                 N_ELEMENTS(cau8SBCSquibFiringStatusCmd),
                                                 (uint32_t*)&gu32SBCTime);
  
  /* Init some variables while we wait for the transfer to occur */
  *pu16Response = CLEAR;
  u8LocalStatus = CLEAR;
  u8Index = CLEAR;
  
  /* Continue only if the transfer was scheduled correctly */
  if(u32Status == CLEAR)
  {
    while(1u > u32fnSchedIsTxDone(gu32SBCTime))
    {
      /* Wait here for the transfer to happen */
    };

    /* We will ignore the first response since, according to the CG147's */
    /* spec, it contains unknown data.                                   */
    for(; u8Index < (N_ELEMENTS(cau8SBCSquibFiringStatusCmd) - 1u);
        u8Index++)
    {
      u8LocalStatus = u8fnCG147ExtractResponse((uint32_t*)&au32LocalResults[u8Index + 1u],
                                               (uint8_t*)&au8LocalResults[u8Index]);

      if(CLEAR == u8LocalStatus)
      {
        if(au8LocalResults[u8Index] > SBC_FIRED_SQUIB_MIN_TIME)
        {
          *pu16Response |= (BIT0 << (u8Index));
        }
        else
        {
          /* Nothing */
        } /* end else Min time surpassed */
      } /* End if u32TempStatus is clear */
      else
      {
        /* Failed. Leave */
        u32Status = STATUS_DATA_TRANSFER_ERROR;
        break;
      } /* End else u32TempStatus is (not) clear */
    }
    /* End FOR */
  }
  else
  {
    /* Exit */
    u32Status = STATUS_SCHEDULER_PROBLEM;
  }
  return (u32Status);
}
/*
 ******************************************************************************
 *
 *  End of file.
 *
 ******************************************************************************
 */